package com.example.aboutwork.phaser;

import java.lang.invoke.MethodHandles;
import java.lang.invoke.VarHandle;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.locks.LockSupport;

public class PhaserCopy {

    /*
     * This class implements an extension of X10 "clocks".  Thanks to
     * Vijay Saraswat for the idea, and to Vivek Sarkar for
     * enhancements to extend functionality.
     */

    /**
     * Primary state representation, holding four bit-fields:
     * <p>
     * unarrived  -- the number of parties yet to hit barrier (bits  0-15)
     * parties    -- the number of parties to wait            (bits 16-31)
     * phase      -- the generation of the barrier            (bits 32-62)
     * terminated -- set if barrier is terminated             (bit  63 / sign)
     * <p>
     * Except that a phaser with no registered parties is
     * distinguished by the otherwise illegal state of having zero
     * parties and one unarrived parties (encoded as EMPTY below).
     * <p>
     * To efficiently maintain atomicity, these values are packed into
     * a single (atomic) long. Good performance relies on keeping
     * state decoding and encoding simple, and keeping race windows
     * short.
     * <p>
     * All state updates are performed via CAS except initial
     * registration of a sub-phaser (i.e., one with a non-null
     * parent).  In this (relatively rare) case, we use built-in
     * synchronization to lock while first registering with its
     * parent.
     * <p>
     * The phase of a subphaser is allowed to lag that of its
     * ancestors until it is actually accessed -- see method
     * reconcileState.
     */
    private volatile long state;

    // 0-15 未到达的parties 16-31已经到达等待执行的parties 32-62 generations 63 / sign 是否结束
    private static final int MAX_PARTIES = 0xffff;
    private static final int MAX_PHASE = Integer.MAX_VALUE;
    private static final int PARTIES_SHIFT = 16;
    private static final int PHASE_SHIFT = 32;
    private static final int UNARRIVED_MASK = 0xffff;      // to mask ints
    private static final long PARTIES_MASK = 0xffff0000L; // to mask longs
    private static final long COUNTS_MASK = 0xffffffffL;
    private static final long TERMINATION_BIT = 1L << 63;

    // some special values  ONE_DEREGISTER 是由一个Arrival party 和一个WAITING party 二者之差等于0
    private static final int ONE_ARRIVAL = 1;
    private static final int ONE_PARTY = 1 << PARTIES_SHIFT;
    // arrivedOf(ONE_DEREGISTER)=0  unarrivedOf(ONE_DEREGISTER)=1  partiesOf(ONE_DEREGISTER)=1
    private static final int ONE_DEREGISTER = ONE_ARRIVAL | ONE_PARTY;
    private static final int EMPTY = 1;

    // The following unpacking methods are usually manually inlined

    public static void main(String[] args) {
        System.err.println(Integer.toBinaryString(ONE_ARRIVAL));
        System.err.println(Integer.toBinaryString(ONE_PARTY));
        System.err.println(Integer.toBinaryString(ONE_DEREGISTER));
        System.err.println(unarrivedOf(ONE_DEREGISTER));
        System.err.println(partiesOf(ONE_DEREGISTER));
        System.err.println(arrivedOf(ONE_DEREGISTER));
    }

    private static int unarrivedOf(long s) {
        int counts = (int) s;
        return (counts == EMPTY) ? 0 : (counts & UNARRIVED_MASK);
    }

    private static int partiesOf(long s) {
        return (int) s >>> PARTIES_SHIFT;
    }

    private static int phaseOf(long s) {
        return (int) (s >>> PHASE_SHIFT);
    }

    //等待中的party - 尚未到达的party
    private static int arrivedOf(long s) {
        int counts = (int) s;
        return (counts == EMPTY) ? 0 :
                (counts >>> PARTIES_SHIFT) - (counts & UNARRIVED_MASK);
    }

    /**
     * The parent of this phaser, or null if none.
     */
    private final PhaserCopy parent;

    /**
     * The root of phaser tree. Equals this if not in a tree.
     */
    private final PhaserCopy root;

    /**
     * Heads of Treiber stacks for waiting threads. To eliminate
     * contention when releasing some threads while adding others, we
     * use two of them, alternating across even and odd phases.
     * Subphasers share queues with root to speed up releases.
     */
    private final AtomicReference<PhaserCopy.QNode> evenQ;
    private final AtomicReference<PhaserCopy.QNode> oddQ;

    /**
     * Returns message string for bounds exceptions on arrival.
     */
    private String badArrive(long s) {
        return "Attempted arrival of unregistered party for " +
                stateToString(s);
    }

    /**
     * Returns message string for bounds exceptions on registration.
     */
    private String badRegister(long s) {
        return "Attempt to register more than " +
                MAX_PARTIES + " parties for " + stateToString(s);
    }

    /**
     * Main implementation for methods arrive and arriveAndDeregister.
     * Manually tuned to speed up and minimize race windows for the
     * common case of just decrementing unarrived field.
     *
     * @param adjust value to subtract from state;
     *               ONE_ARRIVAL for arrive,
     *               ONE_DEREGISTER for arriveAndDeregister
     */
    private int doArrive(int adjust) {
        final PhaserCopy root = this.root;
        for (; ; ) {
            long s = (root == this) ? state : reconcileState();
            int phase = (int) (s >>> PHASE_SHIFT);
            if (phase < 0)
                return phase;
            int counts = (int) s;
            int unarrived = (counts == EMPTY) ? 0 : (counts & UNARRIVED_MASK);
            if (unarrived <= 0)

                throw new IllegalStateException(badArrive(s));
            if (STATE.compareAndSet(this, s, s -= adjust)) {
                if (unarrived == 1) {

                    // base of next state 先拿到等待中的parties 作为下一个状态的基础
                    // 其后16bit都是0 作为当前phase未达到party的计数基础
                    long n = s & PARTIES_MASK;

                    int nextUnarrived = (int) n >>> PARTIES_SHIFT; // 计算出等待中（未到达）的parties

                    if (root == this) { //如果当前节点到了head位置 就有资格进行操作了

                        /**
                         *  protected boolean onAdvance(int phase, int registeredParties) {
                         *         return registeredParties == 0;
                         *     }
                         *     这里判断条件 实际上是有重复的  但由于onAdvance方法是可以override 用户可以自定义
                         *     这种不可控 需要使用者自行处理 变成了一种退出条件 （添加了terminal标记）
                         *
                         *
                         */
                        if (onAdvance(phase, nextUnarrived))
                            n |= TERMINATION_BIT;

                        else if (nextUnarrived == 0)
                            n |= EMPTY; //set the rightest bit 1 实际上对应的是这里 if(unarrived==1)

                        else
                            n |= nextUnarrived; // 添加未达到的party
                        //更新phase
                        int nextPhase = (phase + 1) & MAX_PHASE;
                        n |= (long) nextPhase << PHASE_SHIFT;

                        STATE.compareAndSet(this, s, n);

                        // 释放等待者   LockSupport.unpark(t);
                        releaseWaiters(phase);

                    } else if (nextUnarrived == 0) { // propagate deregistration  传递注销
                        phase = parent.doArrive(ONE_DEREGISTER);
                        STATE.compareAndSet(this, s, s | EMPTY);
                    } else
                        phase = parent.doArrive(ONE_ARRIVAL);
                }
                return phase;
            }
        }
    }

    /**
     * Implementation of register, bulkRegister.
     *
     * @param registrations number to add to both parties and
     *                      unarrived fields. Must be greater than zero.
     */
    private int doRegister(int registrations) {
        // adjustment to state
        long adjust = ((long) registrations << PARTIES_SHIFT) | registrations;

        final PhaserCopy parent = this.parent;

        int phase;

        for (; ; ) {
            long s = (parent == null) ? state : reconcileState();
            int counts = (int) s;

            int parties = counts >>> PARTIES_SHIFT;

            int unarrived = counts & UNARRIVED_MASK;

            if (registrations > MAX_PARTIES - parties)
                throw new IllegalStateException(badRegister(s));

            phase = (int) (s >>> PHASE_SHIFT);

            if (phase < 0)
                break;

            if (counts != EMPTY) {                  // not 1st registration
                if (parent == null || reconcileState() == s) {
                    if (unarrived == 0)             // wait out advance 提前等待
                        root.internalAwaitAdvance(phase, null);
                    else if (STATE.compareAndSet(this, s, s + adjust))
                        break;
                }
            } else if (parent == null) {              // 1st root registration
                long next = ((long) phase << PHASE_SHIFT) | adjust;
                if (STATE.compareAndSet(this, s, next))
                    break;
            } else {
                // 第一来注册 且parent!=null ==> counts==EMPTY && parent!=null
                // 枷锁后 变量状态 state 需要重新检测 可能存在变化
                synchronized (this) {               // 1st sub registration
                    if (state == s) {               // recheck under lock
                        phase = parent.doRegister(1);
                        if (phase < 0)
                            break;
                        // finish registration whenever parent registration
                        // succeeded, even when racing with termination,
                        // since these are part of the same "transaction".
                        // 成功更新数据后 才退出
                        while (!STATE.weakCompareAndSet(this, s, ((long) phase << PHASE_SHIFT) | adjust)) {
                            s = state;
                            phase = (int) (root.state >>> PHASE_SHIFT);
                            // assert (int)s == EMPTY;
                        }
                        break;
                    }
                }
            }
        }
        return phase;
    }

    /**
     * Resolves lagged phase propagation from root if necessary.
     * Reconciliation normally occurs when root has advanced but
     * subphasers have not yet done so, in which case they must finish
     * their own advance by setting unarrived to parties (or if
     * parties is zero, resetting to unregistered EMPTY state).
     *
     * @return reconciled state
     */
    // its purpose is to ensure the root.state equals current state ,
    // implying that the same phase
    private long reconcileState() {
        final PhaserCopy root = this.root;
        long s = state;
        if (root != this) {
            int phase, p;
            // CAS to root phase with current parties, tripping unarrived
            while ((phase = (int) (root.state >>> PHASE_SHIFT)) !=
                    (int) (s >>> PHASE_SHIFT) &&
                    !STATE.weakCompareAndSet
                            (this, s,
                                    s = (((long) phase << PHASE_SHIFT) |
                                            ((phase < 0) ? (s & COUNTS_MASK) :
                                                    (((p = (int) s >>> PARTIES_SHIFT) == 0) ? EMPTY :
                                                            ((s & PARTIES_MASK) | p))))))
                s = state;
        }
        return s;
    }

    /**
     * Creates a new phaser with no initially registered parties, no
     * parent, and initial phase number 0. Any thread using this
     * phaser will need to first register for it.
     */
    public PhaserCopy() {
        this(null, 0);
    }

    /**
     * Creates a new phaser with the given number of registered
     * unarrived parties, no parent, and initial phase number 0.
     *
     * @param parties the number of parties required to advance to the
     *                next phase
     * @throws IllegalArgumentException if parties less than zero
     *                                  or greater than the maximum number of parties supported
     */
    public PhaserCopy(int parties) {
        this(null, parties);
    }

    /**
     * Equivalent to {@link #PhaserCopy(PhaserCopy, int) PhaserCopy(parent, 0)}.
     *
     * @param parent the parent phaser
     */
    public PhaserCopy(PhaserCopy parent) {
        this(parent, 0);
    }

    /**
     * Creates a new phaser with the given parent and number of
     * registered unarrived parties.  When the given parent is non-null
     * and the given number of parties is greater than zero, this
     * child phaser is registered with its parent.
     *
     * @param parent  the parent phaser
     * @param parties the number of parties required to advance to the
     *                next phase
     * @throws IllegalArgumentException if parties less than zero
     *                                  or greater than the maximum number of parties supported
     */
    public PhaserCopy(PhaserCopy parent, int parties) {
        if (parties >>> PARTIES_SHIFT != 0)
            throw new IllegalArgumentException("Illegal number of parties");
        int phase = 0;
        this.parent = parent;
        if (parent != null) {
            final PhaserCopy root = parent.root;
            this.root = root;
            this.evenQ = root.evenQ;
            this.oddQ = root.oddQ;
            if (parties != 0)
                phase = parent.doRegister(1);
        } else {
            this.root = this;
            this.evenQ = new AtomicReference<>();
            this.oddQ = new AtomicReference<>();
        }
        this.state = (parties == 0) ? (long) EMPTY :
                ((long) phase << PHASE_SHIFT) |
                        ((long) parties << PARTIES_SHIFT) |
                        ((long) parties);
    }

    /**
     * Adds a new unarrived party to this phaser.  If an ongoing
     * invocation of {@link #onAdvance} is in progress, this method
     * may await its completion before returning.  If this phaser has
     * a parent, and this phaser previously had no registered parties,
     * this child phaser is also registered with its parent. If
     * this phaser is terminated, the attempt to register has
     * no effect, and a negative value is returned.
     *
     * @return the arrival phase number to which this registration
     * applied.  If this value is negative, then this phaser has
     * terminated, in which case registration has no effect.
     * @throws IllegalStateException if attempting to register more
     *                               than the maximum supported number of parties
     */
    public int register() {
        return doRegister(1);
    }

    /**
     * Adds the given number of new unarrived parties to this phaser.
     * If an ongoing invocation of {@link #onAdvance} is in progress,
     * this method may await its completion before returning.  If this
     * phaser has a parent, and the given number of parties is greater
     * than zero, and this phaser previously had no registered
     * parties, this child phaser is also registered with its parent.
     * If this phaser is terminated, the attempt to register has no
     * effect, and a negative value is returned.
     *
     * @param parties the number of additional parties required to
     *                advance to the next phase
     * @return the arrival phase number to which this registration
     * applied.  If this value is negative, then this phaser has
     * terminated, in which case registration has no effect.
     * @throws IllegalStateException    if attempting to register more
     *                                  than the maximum supported number of parties
     * @throws IllegalArgumentException if {@code parties < 0}
     */
    public int bulkRegister(int parties) {
        if (parties < 0)
            throw new IllegalArgumentException();
        if (parties == 0)
            return getPhase();
        return doRegister(parties);
    }

    /**
     * Arrives at this phaser, without waiting for others to arrive.
     *
     * <p>It is a usage error for an unregistered party to invoke this
     * method.  However, this error may result in an {@code
     * IllegalStateException} only upon some subsequent operation on
     * this phaser, if ever.
     *
     * @return the arrival phase number, or a negative value if terminated
     * @throws IllegalStateException if not terminated and the number
     *                               of unarrived parties would become negative
     */
    public int arrive() {
        return doArrive(ONE_ARRIVAL);
    }

    /**
     * Arrives at this phaser and deregisters from it without waiting
     * for others to arrive. Deregistration reduces the number of
     * parties required to advance in future phases.  If this phaser
     * has a parent, and deregistration causes this phaser to have
     * zero parties, this phaser is also deregistered from its parent.
     *
     * <p>It is a usage error for an unregistered party to invoke this
     * method.  However, this error may result in an {@code
     * IllegalStateException} only upon some subsequent operation on
     * this phaser, if ever.
     *
     * @return the arrival phase number, or a negative value if terminated
     * @throws IllegalStateException if not terminated and the number
     *                               of registered or unarrived parties would become negative
     */
    public int arriveAndDeregister() {
        return doArrive(ONE_DEREGISTER);
    }

    /**
     * Arrives at this phaser and awaits others. Equivalent in effect
     * to {@code awaitAdvance(arrive())}.  If you need to await with
     * interruption or timeout, you can arrange this with an analogous
     * construction using one of the other forms of the {@code
     * awaitAdvance} method.  If instead you need to deregister upon
     * arrival, use {@code awaitAdvance(arriveAndDeregister())}.
     *
     * <p>It is a usage error for an unregistered party to invoke this
     * method.  However, this error may result in an {@code
     * IllegalStateException} only upon some subsequent operation on
     * this phaser, if ever.
     *
     * @return the arrival phase number, or the (negative)
     * {@linkplain #getPhase() current phase} if terminated
     * @throws IllegalStateException if not terminated and the number
     *                               of unarrived parties would become negative
     */
    public int arriveAndAwaitAdvance() {

        // Specialization of doArrive+awaitAdvance eliminating some reads/paths
        final PhaserCopy root = this.root;
        for (; ; ) {
            long s = (root == this) ? state : reconcileState();

            int phase = (int) (s >>> PHASE_SHIFT);

            if (phase < 0)
                return phase;

            int counts = (int) s;

            int unarrived = (counts == EMPTY) ? 0 : (counts & UNARRIVED_MASK);

            if (unarrived <= 0)
                throw new IllegalStateException(badArrive(s));

            if (STATE.compareAndSet(this, s, s -= ONE_ARRIVAL)) {

                if (unarrived > 1)
                    return root.internalAwaitAdvance(phase, null);

                if (root != this)
                    return parent.arriveAndAwaitAdvance();

                long n = s & PARTIES_MASK;  // base of next state

                int nextUnarrived = (int) n >>> PARTIES_SHIFT;

                if (onAdvance(phase, nextUnarrived))
                    n |= TERMINATION_BIT;

                else if (nextUnarrived == 0)
                    n |= EMPTY;

                else
                    n |= nextUnarrived;

                int nextPhase = (phase + 1) & MAX_PHASE;

                n |= (long) nextPhase << PHASE_SHIFT;

                if (!STATE.compareAndSet(this, s, n))
                    return (int) (state >>> PHASE_SHIFT); // terminated

                //unlock threads
                releaseWaiters(phase);

                return nextPhase;
            }
        }
    }

    /**
     * Awaits the phase of this phaser to advance from the given phase
     * value, returning immediately if the current phase is not equal
     * to the given phase value or this phaser is terminated.
     *
     * @param phase an arrival phase number, or negative value if
     *              terminated; this argument is normally the value returned by a
     *              previous call to {@code arrive} or {@code arriveAndDeregister}.
     * @return the next arrival phase number, or the argument if it is
     * negative, or the (negative) {@linkplain #getPhase() current phase}
     * if terminated
     */
    public int awaitAdvance(int phase) {
        final PhaserCopy root = this.root;
        long s = (root == this) ? state : reconcileState();
        int p = (int) (s >>> PHASE_SHIFT);
        if (phase < 0)
            return phase;
        if (p == phase)
            return root.internalAwaitAdvance(phase, null);
        return p;
    }

    /**
     * Awaits the phase of this phaser to advance from the given phase
     * value, throwing {@code InterruptedException} if interrupted
     * while waiting, or returning immediately if the current phase is
     * not equal to the given phase value or this phaser is
     * terminated.
     *
     * @param phase an arrival phase number, or negative value if
     *              terminated; this argument is normally the value returned by a
     *              previous call to {@code arrive} or {@code arriveAndDeregister}.
     * @return the next arrival phase number, or the argument if it is
     * negative, or the (negative) {@linkplain #getPhase() current phase}
     * if terminated
     * @throws InterruptedException if thread interrupted while waiting
     */
    public int awaitAdvanceInterruptibly(int phase)
            throws InterruptedException {
        final PhaserCopy root = this.root;
        long s = (root == this) ? state : reconcileState();
        int p = (int) (s >>> PHASE_SHIFT);
        if (phase < 0)
            return phase;
        if (p == phase) {
            PhaserCopy.QNode node = new PhaserCopy.QNode(this, phase, true, false, 0L);
            p = root.internalAwaitAdvance(phase, node);
            if (node.wasInterrupted)
                throw new InterruptedException();
        }
        return p;
    }

    /**
     * Awaits the phase of this phaser to advance from the given phase
     * value or the given timeout to elapse, throwing {@code
     * InterruptedException} if interrupted while waiting, or
     * returning immediately if the current phase is not equal to the
     * given phase value or this phaser is terminated.
     *
     * @param phase   an arrival phase number, or negative value if
     *                terminated; this argument is normally the value returned by a
     *                previous call to {@code arrive} or {@code arriveAndDeregister}.
     * @param timeout how long to wait before giving up, in units of
     *                {@code unit}
     * @param unit    a {@code TimeUnit} determining how to interpret the
     *                {@code timeout} parameter
     * @return the next arrival phase number, or the argument if it is
     * negative, or the (negative) {@linkplain #getPhase() current phase}
     * if terminated
     * @throws InterruptedException if thread interrupted while waiting
     * @throws TimeoutException     if timed out while waiting
     */
    public int awaitAdvanceInterruptibly(int phase,
                                         long timeout, TimeUnit unit)
            throws InterruptedException, TimeoutException {
        long nanos = unit.toNanos(timeout);
        final PhaserCopy root = this.root;
        long s = (root == this) ? state : reconcileState();
        int p = (int) (s >>> PHASE_SHIFT);
        if (phase < 0)
            return phase;
        if (p == phase) {
            PhaserCopy.QNode node = new PhaserCopy.QNode(this, phase, true, true, nanos);
            p = root.internalAwaitAdvance(phase, node);
            if (node.wasInterrupted)
                throw new InterruptedException();
            else if (p == phase)
                throw new TimeoutException();
        }
        return p;
    }

    /**
     * Forces this phaser to enter termination state.  Counts of
     * registered parties are unaffected.  If this phaser is a member
     * of a tiered set of phasers, then all of the phasers in the set
     * are terminated.  If this phaser is already terminated, this
     * method has no effect.  This method may be useful for
     * coordinating recovery after one or more tasks encounter
     * unexpected exceptions.
     */
    public void forceTermination() {
        // Only need to change root state
        final PhaserCopy root = this.root;
        long s;
        while ((s = root.state) >= 0) {
            if (STATE.compareAndSet(root, s, s | TERMINATION_BIT)) {
                // signal all threads
                releaseWaiters(0); // Waiters on evenQ
                releaseWaiters(1); // Waiters on oddQ
                return;
            }
        }
    }

    /**
     * Returns the current phase number. The maximum phase number is
     * {@code Integer.MAX_VALUE}, after which it restarts at
     * zero. Upon termination, the phase number is negative,
     * in which case the prevailing phase prior to termination
     * may be obtained via {@code getPhase() + Integer.MIN_VALUE}.
     *
     * @return the phase number, or a negative value if terminated
     */
    public final int getPhase() {
        return (int) (root.state >>> PHASE_SHIFT);
    }

    /**
     * Returns the number of parties registered at this phaser.
     *
     * @return the number of parties
     */
    public int getRegisteredParties() {
        return partiesOf(state);
    }

    /**
     * Returns the number of registered parties that have arrived at
     * the current phase of this phaser. If this phaser has terminated,
     * the returned value is meaningless and arbitrary.
     *
     * @return the number of arrived parties
     */
    public int getArrivedParties() {
        return arrivedOf(reconcileState());
    }

    /**
     * Returns the number of registered parties that have not yet
     * arrived at the current phase of this phaser. If this phaser has
     * terminated, the returned value is meaningless and arbitrary.
     *
     * @return the number of unarrived parties
     */
    public int getUnarrivedParties() {
        return unarrivedOf(reconcileState());
    }

    /**
     * Returns the parent of this phaser, or {@code null} if none.
     *
     * @return the parent of this phaser, or {@code null} if none
     */
    public PhaserCopy getParent() {
        return parent;
    }

    /**
     * Returns the root ancestor of this phaser, which is the same as
     * this phaser if it has no parent.
     *
     * @return the root ancestor of this phaser
     */
    public PhaserCopy getRoot() {
        return root;
    }

    /**
     * Returns {@code true} if this phaser has been terminated.
     *
     * @return {@code true} if this phaser has been terminated
     */
    public boolean isTerminated() {
        return root.state < 0L;
    }

    /**
     * Overridable method to perform an action upon impending phase
     * advance, and to control termination. This method is invoked
     * upon arrival of the party advancing this phaser (when all other
     * waiting parties are dormant).  If this method returns {@code
     * true}, this phaser will be set to a final termination state
     * upon advance, and subsequent calls to {@link #isTerminated}
     * will return true. Any (unchecked) Exception or Error thrown by
     * an invocation of this method is propagated to the party
     * attempting to advance this phaser, in which case no advance
     * occurs.
     *
     * <p>The arguments to this method provide the state of the phaser
     * prevailing for the current transition.  The effects of invoking
     * arrival, registration, and waiting methods on this phaser from
     * within {@code onAdvance} are unspecified and should not be
     * relied on.
     *
     * <p>If this phaser is a member of a tiered set of phasers, then
     * {@code onAdvance} is invoked only for its root phaser on each
     * advance.
     *
     * <p>To support the most common use cases, the default
     * implementation of this method returns {@code true} when the
     * number of registered parties has become zero as the result of a
     * party invoking {@code arriveAndDeregister}.  You can disable
     * this behavior, thus enabling continuation upon future
     * registrations, by overriding this method to always return
     * {@code false}:
     *
     * <pre> {@code
     * Phaser phaser = new Phaser() {
     *   protected boolean onAdvance(int phase, int parties) { return false; }
     * };}</pre>
     *
     * @param phase             the current phase number on entry to this method,
     *                          before this phaser is advanced
     * @param registeredParties the current number of registered parties
     * @return {@code true} if this phaser should terminate
     */
    protected boolean onAdvance(int phase, int registeredParties) {
        return registeredParties == 0;
    }

    /**
     * Returns a string identifying this phaser, as well as its
     * state.  The state, in brackets, includes the String {@code
     * "phase = "} followed by the phase number, {@code "parties = "}
     * followed by the number of registered parties, and {@code
     * "arrived = "} followed by the number of arrived parties.
     *
     * @return a string identifying this phaser, as well as its state
     */
    public String toString() {
        return stateToString(reconcileState());
    }

    /**
     * Implementation of toString and string-based error messages.
     */
    private String stateToString(long s) {
        return super.toString() +
                "[phase = " + phaseOf(s) +
                " parties = " + partiesOf(s) +
                " arrived = " + arrivedOf(s) + "]";
    }

    // Waiting mechanics

    /**
     * Removes and signals threads from queue for phase.
     */
    private void releaseWaiters(int phase) {
        PhaserCopy.QNode q;   // first element of queue
        Thread t;  // its thread
        AtomicReference<PhaserCopy.QNode> head = (phase & 1) == 0 ? evenQ : oddQ;
        while ((q = head.get()) != null &&
                q.phase != (int) (root.state >>> PHASE_SHIFT)) {
            if (head.compareAndSet(q, q.next) &&
                    (t = q.thread) != null) {
                q.thread = null;
                LockSupport.unpark(t);
            }
        }
    }

    /**
     * Variant of releaseWaiters that additionally tries to remove any
     * nodes no longer waiting for advance due to timeout or
     * interrupt. Currently, nodes are removed only if they are at
     * head of queue, which suffices to reduce memory footprint in
     * most usages.
     *
     * @return current phase on exit
     */
    private int abortWait(int phase) {
        AtomicReference<PhaserCopy.QNode> head = (phase & 1) == 0 ? evenQ : oddQ;
        for (; ; ) {
            Thread t;
            PhaserCopy.QNode q = head.get();
            int p = (int) (root.state >>> PHASE_SHIFT);
            if (q == null || ((t = q.thread) != null && q.phase == p))
                return p;
            if (head.compareAndSet(q, q.next) && t != null) {
                q.thread = null;
                LockSupport.unpark(t);
            }
        }
    }

    /**
     * The number of CPUs, for spin control
     */
    private static final int NCPU = Runtime.getRuntime().availableProcessors();

    /**
     * The number of times to spin before blocking while waiting for
     * advance, per arrival while waiting. On multiprocessors, fully
     * blocking and waking up a large number of threads all at once is
     * usually a very slow process, so we use rechargeable spins to
     * avoid it when threads regularly arrive: When a thread in
     * internalAwaitAdvance notices another arrival before blocking,
     * and there appear to be enough CPUs available, it spins
     * SPINS_PER_ARRIVAL more times before blocking. The value trades
     * off good-citizenship vs big unnecessary slowdowns.
     */
    static final int SPINS_PER_ARRIVAL = (NCPU < 2) ? 1 : 1 << 8;

    /**
     * Possibly blocks and waits for phase to advance unless aborted.
     * Call only on root phaser.
     *
     * @param phase current phase
     * @param node  if non-null, the wait node to track interrupt and timeout;
     *              if null, denotes noninterruptible wait
     * @return current phase
     */
    private int internalAwaitAdvance(int phase, PhaserCopy.QNode node) {
        // assert root == this;
        releaseWaiters(phase - 1);          // ensure old queue clean 清楚旧的队列

        boolean queued = false;           // true when node is enqueued
        int lastUnarrived = 0;            // to increase spins upon change
        int spins = SPINS_PER_ARRIVAL;
        long s;
        int p;

        while ((p = (int) ((s = state) >>> PHASE_SHIFT)) == phase) {

            if (node == null) {           // spinning in noninterruptible mode  不可打断兜圈模式

                int unarrived = (int) s & UNARRIVED_MASK;

                // cpu affinity
                if (unarrived != lastUnarrived && (lastUnarrived = unarrived) < NCPU) {
                    spins += SPINS_PER_ARRIVAL;
                }

                // 当前线程是否打断
                boolean interrupted = Thread.interrupted();

                // 记录下node数据
                if (interrupted || --spins < 0) { // need node to record intr
                    // 此处node被修改
                    node = new PhaserCopy.QNode(this, phase, false, false, 0L);
                    node.wasInterrupted = interrupted;
                } else
                    Thread.onSpinWait();//兜圈等待 (interrupted || --spins < 0) 的满足
            } else if (node.isReleasable()) // done or aborted
                break;
            else if (!queued) {
                // push onto queue 奇数偶数判断的位运算
                AtomicReference<PhaserCopy.QNode> head = (phase & 1) == 0 ? evenQ : oddQ;

                // 此处node被修改
                PhaserCopy.QNode q = node.next = head.get();

                if ((q == null || q.phase == phase) && (int) (state >>> PHASE_SHIFT) == phase) // avoid stale enq
                    queued = head.compareAndSet(q, node);
            } else {
                //node!=null&&queued&&!node.isReleasable()
                try {
                    ForkJoinPool.managedBlock(node);
                } catch (InterruptedException cantHappen) {
                    node.wasInterrupted = true;
                }
            }
        }

        if (node != null) {
            if (node.thread != null)
                node.thread = null;       // avoid need for unpark()
            if (node.wasInterrupted && !node.interruptible)
                Thread.currentThread().interrupt();
            if (p == phase && (p = (int) (state >>> PHASE_SHIFT)) == phase)
                return abortWait(phase); // possibly clean up on abort
        }
        releaseWaiters(phase);
        return p;
    }

    /**
     * Wait nodes for Treiber stack representing wait queue.
     */
    static final class QNode implements ForkJoinPool.ManagedBlocker {
        final PhaserCopy phaser;
        final int phase;
        final boolean interruptible;
        final boolean timed;
        boolean wasInterrupted;
        long nanos;
        final long deadline;
        volatile Thread thread; // nulled to cancel wait
        PhaserCopy.QNode next;

        QNode(PhaserCopy phaser, int phase, boolean interruptible,
              boolean timed, long nanos) {
            this.phaser = phaser;
            this.phase = phase;
            this.interruptible = interruptible;
            this.nanos = nanos;
            this.timed = timed;
            this.deadline = timed ? System.nanoTime() + nanos : 0L;
            thread = Thread.currentThread();
        }

        public boolean isReleasable() {
            if (thread == null)
                return true;
            if (phaser.getPhase() != phase) {
                thread = null;
                return true;
            }
            if (Thread.interrupted())
                wasInterrupted = true;
            if (wasInterrupted && interruptible) {
                thread = null;
                return true;
            }
            if (timed &&
                    (nanos <= 0L || (nanos = deadline - System.nanoTime()) <= 0L)) {
                thread = null;
                return true;
            }
            return false;
        }

        public boolean block() {
            while (!isReleasable()) {
                if (timed)
                    LockSupport.parkNanos(this, nanos);
                else
                    LockSupport.park(this);
            }
            return true;
        }
    }

    // VarHandle mechanics`
    private static final VarHandle STATE;

    static {
        try {
            MethodHandles.Lookup l = MethodHandles.lookup();
            STATE = l.findVarHandle(PhaserCopy.class, "state", long.class);
        } catch (ReflectiveOperationException e) {
            throw new ExceptionInInitializerError(e);
        }

        // Reduce the risk of rare disastrous classloading in first call to
        // LockSupport.park: https://bugs.openjdk.java.net/browse/JDK-8074773
        Class<?> ensureLoaded = LockSupport.class;
    }
}